__jshelp = {
    /** 系统返回值配置 */
    rescode: {
        succress: 0,            //成功
        fail: -1,               //业务逻辑错误/常规错误
        param_fail: -2,         //参数错误
        db_fail: -3,            //数据库操作错误
        net_fail: -4,           //第三方接口导致错误
        file_fail: -5,          //上传文件错误
        login_fail: -21,        //用户未登录
        auth_fail: -22,         //无权限
        token_fail: -23,        //token验证失败
        undefined_fail: -99     //未定义错误
    },
    /** 抛出一个格式化的错误
     * 
     * @param {String} msg 错误文本
     * @param {Number} code 错误代码
     */
    throwObj: (msg, code = __jshelp.rescode.undefined_fail) => {
        throw {
            msg,
            code
        };
    },
    /** 根据方程式结果,throw相应错误
     * 
     * @param {String} equation 检测方程式
     * @example
     * 错误描述文本首字符为!,则会在文本后面追加'不正确'字样
     * 例如: '!ID'=>'ID不正确'
     * check_params(
     *     !c.request.body.id && '!ID' ||
     *     !c.request.body.name && '!名称' ||
     *     c.request.body.name.toLowerCase()=='admin' && '名称不能为admin'
     * )
     */
    check_params: (equation) => {
        if (equation) {
            __jshelp.throwObj(equation.substr(1) + '不正确！' || equation, __jshelp.rescode.param_fail);
        }
    },
    /** 对象是否为null/undefined/NaN
     * 
     * @param {any} obj 检查对象
     * @param {bool} err 是否要throwObj(undefined_fail)
     */
    isNullOrUndefined: (obj, err) => {
        if (obj === null || obj === undefined) {
            if (err) __jshelp.throwObj('变量未定义');
            return true;
        }
        return false;
    },
    /** 返回对象的真实类型
     * 
     * @param {any} obj 检查对象
     */
    sureType: (obj) => {
        let _type = Object.prototype.toString.call(obj);
        _type = _type.substr(1, _type.length - 2);
        return _type.split(' ')[1];
    },
    isStringObject: (obj, maxlength) => {
        if (__jshelp.sureType(obj) !== 'String') return false;
        if (obj.length > maxlength) return false;
        return true;
    },
    isNumberObject: (obj) => {
        return __jshelp.sureType(obj) === 'Number';
    },
    isDateObject: (obj) => {
        return __jshelp.sureType(obj) === 'Date';
    },
    isArrayObject: (obj) => {
        return __jshelp.sureType(obj) === 'Array';
    },
    isObjectObject: (obj) => {
        return __jshelp.sureType(obj) === 'Object';
    },
    isFunctionObject: (obj) => {
        return __jshelp.sureType(obj) === 'Function';
    },
    isRegExpObject: (obj) => {
        return __jshelp.sureType(obj) === 'RegExp';
    },

    /** 判断对象是否可为数字
     * 
     * @param {*} obj 要判断的对象
     * @param {int || float} min 最小值 <=
     * @param {int || float} max 最大值 >=
     * @example
     * isNumber('a'); //return false;
     * isNumber(1.1); //return true;
     * isNumber(-1, 0); //return false;
     * isNumber(3.1,0,10); //return true;
     */
    isNumber: (obj, min, max) => {
        if (__jshelp.isNumberObject(obj)) obj = obj.toString();

        // isNaN()函数 把空串 空格 以及NUll 按照0来处理 所以先去除，    
        if (obj === "" || obj == null) {
            return false;
        }
        //对于空数组和只有一个数值成员的数组或全是数字组成的字符串，isNaN返回false，例如：'123'、[]、[2]、['123'],isNaN返回false,   
        //所以如果不需要obj包含这些特殊情况，则这个判断改写为if(!isNaN(obj) && typeof obj === 'number' )
        if (isNaN(obj)) {
            return false;
        }

        obj = obj * 1;
        let ret = true;
        if (!__jshelp.isNullOrUndefined(min) && __jshelp.isNumber(min)) {
            min = min * 1;
            ret = min <= obj;
        }
        if (!__jshelp.isNullOrUndefined(max) && __jshelp.isNumber(max)) {
            max = max * 1;
            ret = max >= obj;
        }
        return ret;
    },
    /** 判断对象是否可为数字
     * 
     * @param {String || Number} obj 要判断的对象
     * @param {int || float} min 最小值 <=
     * @param {int || float} max 最大值 >=
     * @example
     * isInt('a'); //return false;
     * isInt(1.1); //return false;
     * isInt(-1, 0); //return false;
     * isInt(3,0,10); //return true;
     */
    isInt: (obj, min, max) => {
        if (__jshelp.isNumberObject(obj)) obj = obj.toString();
        if ((obj + '').indexOf('.') >= 0) return false;
        return __jshelp.isNumber(obj, min, max);
    },
    /** 获取时间比较结果
     * 
     * @param {*} date 比较目标
     * @param {*} curDate 源对象
     * @returns >= 返回true,否则返回false
     */
    compareDate: (date, curDate = new Date()) => {
        if (!__jshelp.isDateObject(date)) date = new Date(date);
        return date >= curDate;
    },
    /** 判断时间是否在时间段内
     * 
     * @param {*} beginDate 起始时间
     * @param {*} endDate 结束时间
     * @param {*} curDate 源对象
     */
    isDuringDate: (beginDate, endDate, curDate = new Date()) => {
        if (!__jshelp.isDateObject(beginDate)) beginDate = new Date(beginDate);
        if (!__jshelp.isDateObject(endDate)) endDate = new Date(endDate);
        if (!__jshelp.isDateObject(curDate)) curDate = new Date(curDate);
        if (curDate >= beginDate && curDate <= endDate) {
            return true;
        }
        return false;
    },
    /** 获取指定时间的时间戳(秒)
     * 
     */
    parseUnitMS:(objDate = new Date()) => {
        return Date.parse(objDate)/1000
    },
    /** 去除字符串首尾空格
     * 
     * @param {string} obj 源对象
     */
    trimStr: (obj) => {
        return obj.replace(/(^\s*)|(\s*$)/g, "");
    },
    /** 重组对象，抽取obj指定的key，并与extend形成新对象
     * 
     * @param {*} obj 源对象
     * @param {*} keys 需要保留的字段
     * @param {*} extend 需要扩展的对象
     */
    regroup: (obj, keys, extend = {}) => {
        let res = keys.reduce((result, key) => {
            if (obj.hasOwnProperty(key)) {
                result[key] = obj[key];
            }
            return result;
        }, {});

        return Object.assign(res, extend);
    },
    /** 深拷贝对象
     * 
     * @param {源对象} obj
     */
    cloneObject: (obj) => {
        var result = Array.isArray(obj) ? [] : {};
        for (var key in obj) {
            if (obj.hasOwnProperty(key)) {
                if (typeof obj[key] === 'object' && obj[key] !== null) {
                    result[key] = __jshelp.cloneObject(obj[key]); //递归复制
                } else {
                    result[key] = obj[key];
                }
            }
        }
        return result;
    },
    /** 将时间格式化为指定字符串
     * 
     * @param {String} fmt 时间格式字符串
     * @param {Date} dt 时间,默认为当前时间
     * @returns {String} 格式化后的字符串
     * @example
     * format_datetime('yyyy-MM-dd HH:mm')
     * 年:y,月:M,日:d
     * 时:H,分:m,秒:s,毫秒:S
     */
    format_datetime: (dt = new Date(), fmt = 'yyyy-MM-dd HH:mm:ss') => {
        if (Object.prototype.toString.call(dt) !== "[object Date]") dt = new Date(dt);
        var o = {
            'M+': dt.getMonth() + 1,
            'd+': dt.getDate(),
            'H+': dt.getHours(),
            'm+': dt.getMinutes(),
            's+': dt.getSeconds(),
            'S+': dt.getMilliseconds()
        };
        //因为date.getFullYear()出来的结果是number类型的,所以为了让结果变成字符串型，下面有两种方法：
        if (/(y+)/.test(fmt)) {
            //第一种：利用字符串连接符“+”给date.getFullYear()+''，加一个空字符串便可以将number类型转换成字符串。
            fmt = fmt.replace(RegExp.$1, (dt.getFullYear() + '').substr(4 - RegExp.$1.length));
        }
        for (var k in o) {
            if (new RegExp('(' + k + ')').test(fmt)) {
                //第二种：使用String()类型进行强制数据类型转换String(date.getFullYear())，这种更容易理解。
                fmt = fmt.replace(RegExp.$1, (RegExp.$1.length == 1) ? (o[k]) : (('00' + o[k]).substr(String(o[k]).length)));
            }
        }
        return fmt;
    },
    //阿拉伯数字转换为简写汉字
    format_numberToSimplifiedChinese: (Num) => {
        for (i = Num.length - 1; i >= 0; i--) {
            Num = Num.replace(',', ''); //替换Num中的“,”
            Num = Num.replace(' ', ''); //替换Num中的空格
        }
        if (types.isNumberObject(Num * 1)) { //验证输入的字符是否为数字
            //alert('请检查小写金额是否正确')
            return;
        }

        let number_arr = ['零', '一', '二', '三', '四', '五', '六', '七', '八', '九'],
            unit_arr = ['', '十', '百', '千', '万', '十', '百', '千', '亿', '十'];

        let newchar;

        //字符处理完毕后开始转换，采用前后两部分分别转换
        let part = String(Num).split('.');

        //小数点前进行转化
        for (i = part[0].length - 1; i >= 0; i--) {
            if (part[0].length > 10) {
                //alert('位数过大，无法计算')
                return '';
            } //若数量超过拾亿单位，提示

            //数字转换
            let tmpnewchar = '';
            let perchar = part[0].charAt(i);
            tmpnewchar = number_arr[perchar] + tmpnewchar;

            //添加单位
            let number_len = part[0].length - i - 1;
            if (number_len = 0 || number_len == 4 || number_len == 8 || number_len == 9) {
                tmpnewchar = tmpnewchar + unit_arr[number_len];
            } else if (perchar != 0) {
                tmpnewchar = tmpnewchar + unit_arr[number_len];
            }

            newchar = tmpnewchar + '';
        }
        //替换所有无用汉字，直到没有此类无用的数字为止
        while (newchar.search('零零') != -1 || newchar.search('零亿') != -1 || newchar.search('亿万') != -1 || newchar.search('零万') != -1) {
            newchar = newchar.replace('零亿', '亿');
            newchar = newchar.replace('亿万', '亿');
            newchar = newchar.replace('零万', '万');
            newchar = newchar.replace('零零', '零');
        }
        //替换以“一十”开头的，为“十”
        if (newchar.indexOf('一十') == 0) {
            newchar = newchar.substr(1);
        }
        //替换以“零”结尾的，为“”
        if (newchar.lastIndexOf('零') == newchar.length - 1) {
            newchar = newchar.substr(0, newchar.length - 1);
        }
        return newchar;
    },
};

const js = __jshelp;